{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:19.015734Z",
     "start_time": "2021-04-02T02:39:17.737431Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision \n",
    "from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence\n",
    "from torchvision import transforms\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "from tqdm.autonotebook import tqdm\n",
    "\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import imshow\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import time\n",
    "\n",
    "from idlmam import train_network, Flatten, weight_reset, View, set_seed\n",
    "from idlmam import AttentionAvg, GeneralScore, DotScore, AdditiveAttentionScore, ApplyAttention, getMaskByFill"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:19.020786Z",
     "start_time": "2021-04-02T02:39:19.017111Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from IPython.display import set_matplotlib_formats\n",
    "set_matplotlib_formats('png', 'pdf')\n",
    "\n",
    "from IPython.display import display_pdf\n",
    "from IPython.display import Latex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:19.027469Z",
     "start_time": "2021-04-02T02:39:19.021895Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "torch.backends.cudnn.deterministic=True\n",
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:19.068731Z",
     "start_time": "2021-04-02T02:39:19.028602Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:19.085718Z",
     "start_time": "2021-04-02T02:39:19.070201Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "B = 128\n",
    "epochs = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.252467Z",
     "start_time": "2021-04-02T02:39:19.087349Z"
    }
   },
   "outputs": [],
   "source": [
    "from io import BytesIO\n",
    "from zipfile import ZipFile\n",
    "from urllib.request import urlopen\n",
    "import re\n",
    "\n",
    "all_data = []\n",
    "resp = urlopen(\"https://download.pytorch.org/tutorial/data.zip\")\n",
    "zipfile = ZipFile(BytesIO(resp.read()))\n",
    "for line in zipfile.open(\"data/eng-fra.txt\").readlines():\n",
    "    line = line.decode('utf-8').lower()#lower case only please\n",
    "    line = re.sub(r\"[-.!?]+\", r\" \", line)#no puntuation\n",
    "    source_lang, target_lang = line.split(\"\\t\")[0:2]\n",
    "    all_data.append( (source_lang.strip(), target_lang.strip()) ) #(english, french)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.265708Z",
     "start_time": "2021-04-02T02:39:20.254416Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('go', 'va')\n",
      "('run', 'cours')\n",
      "('run', 'courez')\n",
      "('wow', 'ça alors')\n",
      "('fire', 'au feu')\n",
      "('help', \"à l'aide\")\n",
      "('jump', 'saute')\n",
      "('stop', 'ça suffit')\n",
      "('stop', 'stop')\n",
      "('stop', 'arrête toi')\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(all_data[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.418728Z",
     "start_time": "2021-04-02T02:39:20.267277Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using  66251 / 135842\n"
     ]
    }
   ],
   "source": [
    "short_subset = [] #the subset we will actually use\n",
    "MAX_LEN = 6\n",
    "for (s, t) in all_data:\n",
    "    if max(len(s.split(\" \")), len(t.split(\" \"))) <= MAX_LEN:\n",
    "        short_subset.append((s,t))\n",
    "print(\"Using \", len(short_subset), \"/\", len(all_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.550299Z",
     "start_time": "2021-04-02T02:39:20.419974Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of Vocab:  24577\n"
     ]
    }
   ],
   "source": [
    "SOS_token = \"<SOS>\" #\"START_OF_SENTANCE_TOKEN\"\n",
    "EOS_token = \"<EOS>\" #\"END_OF_SENTANCE_TOKEN\"\n",
    "PAD_token = \"_PADDING_\"\n",
    "\n",
    "word2indx = {PAD_token:0, SOS_token:1, EOS_token:2}\n",
    "for s, t in short_subset:\n",
    "    for sentance in (s, t):\n",
    "        for word in sentance.split(\" \"):\n",
    "            if word not in word2indx:\n",
    "                word2indx[word] = len(word2indx)\n",
    "print(\"Size of Vocab: \", len(word2indx))\n",
    "#build the inverted dict for looking at the outputs later\n",
    "indx2word = {}\n",
    "for word, indx in word2indx.items():\n",
    "    indx2word[indx] = word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.556031Z",
     "start_time": "2021-04-02T02:39:20.551494Z"
    }
   },
   "outputs": [],
   "source": [
    "class TranslationDataset(Dataset):\n",
    "    \"\"\"\n",
    "    Takes a dataset with tuples of strings (x, y) and\n",
    "    converts them to tuples of int64 tensors. \n",
    "    This makes it easy to encode Seq2Seq problems.\n",
    "    \n",
    "    Strings in the input and output targets will be broken up by spaces\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, lang_pairs, word2indx):\n",
    "        \"\"\"\n",
    "        lang_pairs: a List[Tuple[String,String]] containing the source,target pairs for a Seq2Seq problem. \n",
    "        word2indx: a Map[String,Int] that converts each word in an input string into a unique ID. \n",
    "        \"\"\"\n",
    "        self.lang_pairs = lang_pairs\n",
    "        self.word2indx = word2indx\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.lang_pairs)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        x, y = self.lang_pairs[idx]\n",
    "        x = SOS_token + \" \" + x + \" \" + EOS_token\n",
    "        y = y + \" \" + EOS_token\n",
    "        \n",
    "        #convert to lists of integers\n",
    "        x = [self.word2indx[w] for w in x.split(\" \")]\n",
    "        y = [self.word2indx[w] for w in y.split(\" \")]\n",
    "        \n",
    "        x = torch.tensor(x, dtype=torch.int64)\n",
    "        y = torch.tensor(y, dtype=torch.int64)\n",
    "        \n",
    "        return x, y\n",
    "bigdataset = TranslationDataset(short_subset, word2indx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.561896Z",
     "start_time": "2021-04-02T02:39:20.557175Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "#Want a consistent dataset split\n",
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.572512Z",
     "start_time": "2021-04-02T02:39:20.563126Z"
    }
   },
   "outputs": [],
   "source": [
    "train_size = round(len(bigdataset)*0.9)\n",
    "test_size = len(bigdataset)-train_size\n",
    "train_dataset, test_dataset = torch.utils.data.random_split(bigdataset, [train_size, test_size])\n",
    "\n",
    "def pad_batch(batch):\n",
    "    \"\"\"\n",
    "    Pad items in the batch to the length of the longest item in the batch\n",
    "    \"\"\"\n",
    "    #We actually have two different maxiumum lengths! The max length of the input sequences, and the max \n",
    "    #length of the output sequences. So we will determine each seperatly, and only pad the inputs/outputs\n",
    "    #by the exact amount we need\n",
    "    max_x = max([i[0].size(0) for i in batch])\n",
    "    max_y = max([i[1].size(0) for i in batch])\n",
    "    \n",
    "    PAD = word2indx[PAD_token]\n",
    "    \n",
    "    #We will use the F.pad function to pad each tensor to the right\n",
    "    X = [F.pad(i[0], (0,max_x-i[0].size(0)), value=PAD) for i in batch]\n",
    "    Y = [F.pad(i[1], (0,max_y-i[1].size(0)), value=PAD) for i in batch]\n",
    "    \n",
    "    X, Y = torch.stack(X), torch.stack(Y)\n",
    "    \n",
    "    return (X, Y), Y\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=B, shuffle=True, collate_fn=pad_batch)\n",
    "test_loader = DataLoader(test_dataset, batch_size=B, collate_fn=pad_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.586635Z",
     "start_time": "2021-04-02T02:39:20.573708Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "class Seq2SeqAttention(nn.Module):\n",
    "\n",
    "    def __init__(self, num_embeddings, embd_size, hidden_size, padding_idx=None, layers=1, max_decode_length=20):\n",
    "        super(Seq2SeqAttention, self).__init__()\n",
    "        self.padding_idx = padding_idx\n",
    "        self.hidden_size = hidden_size\n",
    "        self.embd = nn.Embedding(num_embeddings, embd_size, padding_idx=padding_idx)\n",
    "        \n",
    "        #We set the hidden size to half the intended length, because we will make the \n",
    "        #encoder bi-directional. That means we will get 2 hidden state representations\n",
    "        #which we will concatinate together, giving us the desired size!\n",
    "        self.encode_layers = nn.GRU(input_size=embd_size, hidden_size=hidden_size//2, \n",
    "                                       num_layers=layers, bidirectional=True)\n",
    "        #decoder will be uni-directionall, and we need to use CRUCells so that we can \n",
    "        #do the decoding one step at a time\n",
    "        self.decode_layers = nn.ModuleList([nn.GRUCell(embd_size, hidden_size)] + \n",
    "                                     [nn.GRUCell(hidden_size, hidden_size) for i in range(layers-1)])\n",
    "        self.score_net = DotScore(hidden_size)\n",
    "        #predict_word will be a small fully connected network that we use to convert the \n",
    "        #result of the attention mechanism and the local context into a prediction for \n",
    "        #the next word\n",
    "        self.predict_word = nn.Sequential(\n",
    "            nn.Linear(2*hidden_size, hidden_size),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.LayerNorm(hidden_size),\n",
    "            nn.Linear(hidden_size, hidden_size),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.LayerNorm(hidden_size),\n",
    "            nn.Linear(hidden_size, num_embeddings)\n",
    "        )\n",
    "        self.max_decode_length = max_decode_length\n",
    "        self.apply_attn = ApplyAttention()\n",
    "    \n",
    "    def forward(self, input):\n",
    "        #Input should be (B, T) or ((B, T), (B, T'))\n",
    "        if isinstance(input, tuple):\n",
    "            input, target = input\n",
    "        else:\n",
    "            target = None\n",
    "        #What is the batch size?\n",
    "        B = input.size(0)\n",
    "        #What is the max number of input time steps?\n",
    "        T = input.size(1)\n",
    "\n",
    "        x = self.embd(input) #(B, T, D)\n",
    "\n",
    "        #grab the device that the model currently resides on\n",
    "        #we will need this later \n",
    "        device = x.device\n",
    "\n",
    "        mask = getMaskByFill(x)\n",
    "\n",
    "        #We will use the mask to figure out how long \n",
    "        #each input sequence is\n",
    "        seq_lengths = mask.sum(dim=1).view(-1) #shape (B), containing the # of non-zero values\n",
    "        #the sequence lengths will be used to create a packed input for the encoder RNN\n",
    "        x_packed = pack_padded_sequence(x, seq_lengths.cpu(), batch_first=True, enforce_sorted=False)\n",
    "        h_encoded, h_last = self.encode_layers(x_packed)\n",
    "        h_encoded, _ = pad_packed_sequence(h_encoded) #(B, T, 2, D//2) , b/c its bidirectional\n",
    "        h_encoded = h_encoded.view(B, T, -1) #(B, T, D)\n",
    "        #now h_encoded is the result of running the encoder RNN on the input!\n",
    "\n",
    "\n",
    "        #getting the last hidden state is a little trickier\n",
    "        #first the output gets reshaped as (num_layers, directions, batch_size, hidden_size)\n",
    "        #and then we grab the last index in the first dimension, because we want the \n",
    "        #last layer's output\n",
    "        hidden_size = h_encoded.size(2) \n",
    "        h_last = h_last.view(-1, 2, B, hidden_size//2)[-1,:,:,:] #shape is now (2, B, D/2)\n",
    "        #now we will reorder to (B, 2, D/2), and flatten the last two dimensions down to (B, D)\n",
    "        h_last = h_last.permute(1, 0, 2).reshape(B, -1)\n",
    "        \n",
    "        \n",
    "        #End of Encoding portion. h_encoded now contains the representation of the input data!\n",
    "        #h_last has the final ouputs of the RNN, to use as the initial input state for the decoder\n",
    "        \n",
    "        #The first input to the decoder will be the output of the last encoder step\n",
    "        #decoder_input = h_last\n",
    "        \n",
    "        # new hidden states for decoders\n",
    "        h_prevs = [h_last for l in range(len(self.decode_layers))]\n",
    "\n",
    "        #We will save all the attention mechanism results for visualization later!\n",
    "        all_attentions = []\n",
    "        all_predictions = []\n",
    "\n",
    "        #Grab the last item from the input (which should be an EOS marker)\n",
    "        #as the first input for the decoder\n",
    "        #We could also hard-code the SOS marker instead\n",
    "        decoder_input = self.embd(input.gather(1,seq_lengths.view(-1,1)-1).flatten()) #(B, D)\n",
    "\n",
    "        #How many decoding steps should we do?\n",
    "        steps = min(self.max_decode_length, T)\n",
    "        #If we are training, the target values tells us exactly\n",
    "        #how many steps to take\n",
    "        if target is not None: #We know the exact decode length!\n",
    "            steps = target.size(1)\n",
    "        \n",
    "        #Do we use teacher forcing (true) or auto-regressive (false)\n",
    "        teacher_forcing = np.random.choice((True,False))\n",
    "        for t in range(steps):\n",
    "            x_in = decoder_input #(B, D)\n",
    "\n",
    "            for l in range(len(self.decode_layers)):\n",
    "                h_prev = h_prevs[l] \n",
    "                h = self.decode_layers[l](x_in, h_prev)\n",
    "\n",
    "                h_prevs[l] = h\n",
    "                x_in = h\n",
    "            h_decoder = x_in #(B, D), we now have the hidden state for the decoder at this time step\n",
    "\n",
    "            #This is the attention mechanism, lets look at all the previous encoded states and \n",
    "            #see which look relevant\n",
    "\n",
    "            scores = self.score_net(h_encoded, h_decoder) #(B, T, 1)\n",
    "            context, weights = self.apply_attn(h_encoded, scores, mask=mask)\n",
    "\n",
    "            #save the attention weights for visualization later\n",
    "            all_attentions.append( weights.detach() ) #we are detaching the weights because we \n",
    "            #do not want to compute anything with them anymore, we just want to save their \n",
    "            #values to make visualizations\n",
    "\n",
    "            #Now lets compute the final representation by concatinating the \n",
    "            #attention result and the initial context\n",
    "            word_pred = torch.cat((context, h_decoder), dim=1) #(B, D) + (B, D)  -> (B, 2*D)\n",
    "            #and get a prediction about what the next token is by pushing it\n",
    "            #through a small fully-connected network\n",
    "            word_pred = self.predict_word(word_pred) #(B, 2*D) -> (B, V)\n",
    "            all_predictions.append(word_pred)\n",
    "    \n",
    "            #Now we have $\\hat{y}_t$! we need to select the input for the next\n",
    "            #time step. We use torch.no_grad() because the gradient will \n",
    "            #carry through the hidden states of the RNN, not the input tokens\n",
    "            with torch.no_grad():\n",
    "                if self.training:\n",
    "                    if target is not None and teacher_forcing:\n",
    "                        #We have the target and selected teacher forcing, so use the\n",
    "                        #correct next answer\n",
    "                        next_words = target[:,t].squeeze()\n",
    "                    else:\n",
    "                        #Sample the next token based on the predictions made\n",
    "                        next_words = torch.multinomial(F.softmax(word_pred, dim=1), 1)[:,-1]\n",
    "                else:\n",
    "                    #we are trying to make an actual prediction, so take the most likely word\n",
    "                    #we could improve this by using temperature and sampling like we did \n",
    "                    #for the CharRNN model!\n",
    "                    next_words = torch.argmax(word_pred, dim=1)\n",
    "            #end of torch.no_grad()\n",
    "            \n",
    "            #We've decided what the next tokens are, we are back to using\n",
    "            #the gradient calculation so that the embedding layer is adjusted\n",
    "            #appropriately during training. \n",
    "            decoder_input = self.embd(next_words.to(device))\n",
    "    \n",
    "        #done decoding!\n",
    "        if self.training: #When training, only the predictions are important\n",
    "            return torch.stack(all_predictions, dim=1)\n",
    "        else:#When evaluatin, we also want to look at the attention weights\n",
    "            return torch.stack(all_predictions, dim=1), torch.stack(all_attentions, dim=1).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.592283Z",
     "start_time": "2021-04-02T02:39:20.587774Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.667146Z",
     "start_time": "2021-04-02T02:39:20.593411Z"
    }
   },
   "outputs": [],
   "source": [
    "epochs = 20\n",
    "seq2seq = Seq2SeqAttention(len(word2indx), 64, 256, padding_idx=word2indx[PAD_token], layers=3, max_decode_length=MAX_LEN+2)\n",
    "for p in seq2seq.parameters():\n",
    "    p.register_hook(lambda grad: torch.clamp(grad, -10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:39:20.671422Z",
     "start_time": "2021-04-02T02:39:20.668372Z"
    }
   },
   "outputs": [],
   "source": [
    "def CrossEntLossTime(x, y):\n",
    "    \"\"\"\n",
    "    x: output with shape (B, T, V)\n",
    "    y: labels with shape (B, T')\n",
    "    \n",
    "    \"\"\"\n",
    "    if isinstance(x, tuple):\n",
    "        x, _ = x\n",
    "    #We do not want to compute a loss for items that have been padded out!\n",
    "    cel = nn.CrossEntropyLoss(ignore_index=word2indx[PAD_token])\n",
    "    T = min(x.size(1), y.size(1))\n",
    "    \n",
    "    loss = 0\n",
    "    for t in range(T):\n",
    "        loss += cel(x[:,t,:], y[:,t])\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:49:02.771218Z",
     "start_time": "2021-04-02T02:39:20.672587Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "202e44794cb44d2485879cfaebfc5601",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Epoch'), FloatProgress(value=0.0, max=20.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=466.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "seq2seq_results = train_network(seq2seq, CrossEntLossTime, train_loader,epochs=epochs, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:49:03.022473Z",
     "start_time": "2021-04-02T02:49:02.772787Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='epoch', ylabel='train loss'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(x='epoch', y='train loss', data=seq2seq_results, label='Seq2Seq')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:49:03.028281Z",
     "start_time": "2021-04-02T02:49:03.023936Z"
    }
   },
   "outputs": [],
   "source": [
    "def plot_heatmap(src, trg, scores):\n",
    "    fig, ax = plt.subplots()\n",
    "    heatmap = ax.pcolor(scores, cmap='gray')\n",
    "\n",
    "    ax.set_xticklabels(trg, minor=False, rotation='vertical')\n",
    "    ax.set_yticklabels(src, minor=False)\n",
    "\n",
    "    # put the major ticks at the middle of each cell\n",
    "    # and the x-ticks on top\n",
    "    ax.xaxis.tick_top()\n",
    "    ax.set_xticks(np.arange(scores.shape[1]) + 0.5, minor=False)\n",
    "    ax.set_yticks(np.arange(scores.shape[0]) + 0.5, minor=False)\n",
    "    ax.invert_yaxis()\n",
    "\n",
    "    plt.colorbar(heatmap)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:49:03.073143Z",
     "start_time": "2021-04-02T02:49:03.029730Z"
    }
   },
   "outputs": [],
   "source": [
    "seq2seq = seq2seq.eval().cpu()\n",
    "def results(indx):\n",
    "    eng_x, french_y = test_dataset[indx]\n",
    "    eng_str = \" \".join([indx2word[i] for i in eng_x.cpu().numpy()])\n",
    "    french_str = \" \".join([indx2word[i] for i in french_y.cpu().numpy()])\n",
    "    print(\"Input:     \", eng_str)\n",
    "    print(\"Target:    \", french_str)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        preds, attention = seq2seq(eng_x.unsqueeze(0))\n",
    "        p = torch.argmax(preds, dim=2)\n",
    "    pred_str = \" \".join([indx2word[i] for i in p[0,:].cpu().numpy()])\n",
    "    print(\"Predicted: \", pred_str)\n",
    "    plot_heatmap(eng_str.split(\" \"), pred_str.split(\" \"), attention.T.cpu().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:49:03.431726Z",
     "start_time": "2021-04-02T02:49:03.074711Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input:      <SOS> some animals are afraid of fire <EOS>\n",
      "Target:     certains animaux craignent le feu <EOS>\n",
      "Predicted:  les animaux ont peur du feu <EOS> <EOS>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/edraff/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:5: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  \"\"\"\n",
      "/home/edraff/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:6: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  \n"
     ]
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "results(12) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:49:03.779389Z",
     "start_time": "2021-04-02T02:49:03.433053Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input:      <SOS> what is the weather like today <EOS>\n",
      "Target:     comment est le temps aujourd'hui <EOS>\n",
      "Predicted:  quel temps fait il aujourd'hui <EOS> <EOS> <EOS>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/edraff/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:5: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  \"\"\"\n",
      "/home/edraff/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:6: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  \n"
     ]
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "results(13) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-02T02:49:04.114861Z",
     "start_time": "2021-04-02T02:49:03.780582Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input:      <SOS> no one disagreed <EOS>\n",
      "Target:     personne ne fut en désaccord <EOS>\n",
      "Predicted:  personne n'exprima de désaccord <EOS>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/edraff/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:5: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  \"\"\"\n",
      "/home/edraff/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:6: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  \n"
     ]
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "results(16) "
   ]
  }
 ],
 "metadata": {
  "author": "BLUE About Validation Loss?",
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": false,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "latex_metadata": {
   "title": "Sequence to Sequence"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
